home *** CD-ROM | disk | FTP | other *** search
/ Gekikoh Dennoh Club 2 / Gekikoh Dennoh Club Vol. 2 (Japan).7z / Gekikoh Dennoh Club Vol. 2 (Japan) (Track 01).bin / games / rosa2 / src / rosa.c next >
Text File  |  1997-09-27  |  39KB  |  1,644 lines
  1.  
  2. #include  "rosa.h"
  3. #include  "zfunc.h"
  4.  
  5. void main();
  6. static void    PreGame(void);
  7. static void    GameMain(void);
  8. static void    Term(void);
  9. static char    MyInit(void);
  10. static void    MazeDisp(void);
  11. static void    BlockDraw(short i,short j);
  12. static void    TileDraw(short i,short j);
  13. static void    SpInit(void);
  14. static char    GameMainLoop(void);
  15. static void    MyChrMove(void);
  16. static void    DispSprite(void);
  17. static void    Gate(void);
  18. static char    Demo(void);
  19. static char    MazeLoad(void);
  20. static char    CreateEnemy(short i , short j,char Type);
  21. static char    Bgm(unsigned char i);
  22. static char    BgmRead(void);
  23. static void    Se(unsigned char i);
  24. static char    SeRead(void);
  25. static void    EnemyMain(void);
  26. static char    EnemyInit(void);
  27. static char    GateInit(void);
  28. static char    CreateGate(short i, short j);
  29. static void    EnemyOikake1(_Enemy *Enemy);
  30. static void    EnemyOikake2(_Enemy *Enemy);
  31. static void    WaitVDisp(void);
  32. static void    StageClear(void);
  33. static void    MyChrDead(void);
  34. static void    GameOver(void);
  35. static void    ScoreDisp(void);
  36. static void    Ending(void);
  37. static void    DispStage(void);
  38.  
  39. static _Sprite       *sp;
  40. static char          GameStatus;
  41. static unsigned char GameStage;
  42. static unsigned char *MazePtr;
  43. static unsigned int  MazeCnt;
  44. static _Enemy        *Start     =(_Enemy *)NULL
  45.                     ,*End       =(_Enemy *)NULL;
  46. static _Gate         *GateStart =(_Gate *)NULL
  47.                     ,*GateEnd   =(_Gate *)NULL;
  48. static unsigned char EnemyCnt;
  49. static char          BgmFlag;
  50. static unsigned char *BgmPtr[32];
  51. static int           BgmSize[32];
  52. static unsigned char *SePtr[32];
  53. static int           SeSize[32];
  54. static short         CursorY;
  55. static char          PushFlag;
  56. static unsigned int  Score;
  57. static unsigned int  HiScore=3000;
  58. static char          MyLeft;
  59. static char          EnemyDownFlag;
  60. static unsigned char ContinueCnt=0;
  61. static unsigned int  ContinueMazeCnt;
  62. static unsigned int  ExtendEvery = 0;
  63. static char          PushAFlag;
  64.  
  65.  
  66. void
  67. main()
  68. {
  69.   int i;
  70.  
  71.   char *OpmName = "OPM";
  72.   int  hOpm;
  73.  
  74.   hOpm = OPEN(OpmName,0x001);    /* 適当な常駐チェックです */
  75.   if (hOpm < 0) {
  76.      printf("サウンド・ドライバが常駐していません。終了します\n");
  77.      EXIT();
  78.   }
  79.   CLOSE(hOpm);
  80.  
  81.  
  82.   for (i=0;i<32;i++) {
  83.     BgmPtr[i] = (unsigned char *)NULL;
  84.     SePtr[i]  = (unsigned char *)NULL;
  85.   }
  86.   MazePtr = (unsigned char *)NULL;
  87.  
  88.   if (!MazeLoad())  Term();
  89.   if (!BgmRead())   Term();
  90.   if (!SeRead())    Term();
  91.  
  92.   PreGame();
  93.   GameMain();
  94.   Term();
  95. }
  96.  
  97. static void
  98. PreGame(void)
  99. {
  100.   int i;
  101.  
  102.   B_SUPER(0);
  103.  
  104.  
  105.   CRTMOD(6);
  106.   G_CLR_ON();
  107.   B_CUROFF();
  108.   SP_OFF();
  109.   SpInit();
  110.   DispSprite();
  111.   BGCTRLST(1,1,1);
  112.   BGSCRLST(1,0,0);
  113.   BGTEXTCL(1,0x0100);
  114.   SP_ON();
  115.  
  116.   Bgm(0);
  117.   for  (i=0;i<30;i++)  WaitVDisp(); /* 音色設定までの空ループ */
  118.  
  119. }
  120.  
  121. static void
  122. GameMain(void)
  123. {
  124.   if (!MyInit())    Term();
  125.   if (!EnemyInit()) Term();
  126.   if (!GateInit())  Term();
  127.  
  128.   GameStatus = 0;
  129.   BgmFlag    = 0;
  130.  
  131.   while ( !(GameMainLoop()) );
  132. }
  133.  
  134. static void
  135. Term(void)
  136. {
  137.   _Gate  *GatePtr,*GateDummy;
  138.   _Enemy *Enemy,*EnemyDummy;
  139.   int i;
  140.  
  141.   BgmStop();
  142.  
  143.  
  144.   if (MazePtr != NULL) free(MazePtr);
  145.  
  146.   for (i=0;i<32;i++) {
  147.     if (BgmPtr[i] != NULL)  free(BgmPtr[i]);
  148.     if (SePtr[i]  != NULL)  free(SePtr[i]);
  149.   }
  150.  
  151.   if (My != NULL) free(My);
  152.  
  153.   if (GateStart != NULL  && GateEnd != NULL)  {
  154.     GatePtr = GateStart->Next;
  155.     while (GatePtr->Next != NULL) {
  156.       GateDummy           = GatePtr;
  157.       GatePtr->Prev->Next = GatePtr->Next;
  158.       GatePtr->Next->Prev = GatePtr->Prev;
  159.       GatePtr             = GatePtr->Next;
  160.       free(GateDummy);
  161.     }
  162.   }
  163.  
  164.   if (GateStart != NULL) free(GateStart);
  165.   if (GateEnd   != NULL) free(GateEnd);
  166.  
  167.   if (Start != NULL && End != NULL) {
  168.     Enemy = Start->Next;
  169.     while (Enemy->Next != NULL) {
  170.       EnemyDummy        = Enemy;
  171.       Enemy->Prev->Next = Enemy->Next;
  172.       Enemy->Next->Prev = Enemy->Prev;
  173.       Enemy             = Enemy->Next;
  174.       free(EnemyDummy);
  175.     }
  176.   }
  177.  
  178.   if (Start != NULL) free(Start);
  179.   if (End   != NULL) free(End);
  180.  
  181.   KFLUSHIO( 0xFE );
  182.   B_CURON();
  183.   EXIT();
  184. }
  185.  
  186. static void
  187. SpInit(void)
  188. {
  189.   int i;
  190.   
  191.   (_Sprite *)sp = (_Sprite *)Sprite;
  192.  
  193.   for (i=0;i<128;i++) {
  194.     sp->Pri = 0;
  195.     sp++;
  196.   }
  197. }
  198.  
  199. static char
  200. GameMainLoop(void)
  201. {
  202.   _Gate  *GatePtr,*Dummy;
  203.   _Enemy *Enemy,*EnemyDummy;
  204.   int    i=0;
  205.  
  206.  
  207.   if ( *(char *)0x080C == 0x02) { 
  208.     CRTMOD(16);
  209.     G_CLR_ON();
  210.     B_CURON();
  211.     return -1;
  212.   }
  213.  
  214.   switch (GameStatus) {
  215.     case 0:{
  216.       SpInit();
  217.       (_Sprite *)sp = (_Sprite *)Sprite;
  218.       if (!BgmFlag)  {
  219.         if (!Bgm(1)) Term();
  220.         MazeCnt = 0;
  221.         CursorY = 224;
  222.         if (ContinueCnt) CursorY = 208;
  223.         MazeDisp();
  224.       }
  225.       if (Demo()) {
  226.         CRTMOD(16);
  227.         G_CLR_ON();
  228.         B_CURON();
  229.         return -1;
  230.       }
  231.       return 0;
  232.     }
  233.     case 1:{
  234.       SpInit();
  235.       (_Sprite *)sp = (_Sprite *)Sprite;
  236.       if (!BgmFlag) DispStage();
  237.       MyChrMove();
  238.       EnemyMain();
  239.       Gate();
  240.       ScoreDisp();
  241.       DispSprite();
  242.       if (!BgmFlag) { 
  243.         if (!Bgm(2)) Term();
  244.         while (i<45) {
  245.           WaitVDisp();
  246.           i++;
  247.         }
  248.       }
  249.       BgmFlag = 1;
  250.       if (!EnemyCnt)  {
  251.          GameStatus = 2;
  252.       }
  253.       if (GameStatus == 6) BgmFlag = 0;
  254.       if (*(char *)0x0800 == 0x02) GameStatus = 3;
  255.       return 0;
  256.     }
  257.     case 2: {
  258.       StageClear();
  259.       GatePtr = GateStart->Next;
  260.       while (GatePtr->Next != NULL) {
  261.         Dummy    = GatePtr;
  262.         GatePtr->Prev->Next = GatePtr->Next;
  263.         GatePtr->Next->Prev = GatePtr->Prev;
  264.         GatePtr  = GatePtr->Next;
  265.         free(Dummy);
  266.       }
  267.       GameStage++;
  268.       GameStatus = 1;
  269.       BgmFlag    = 0;
  270.       ContinueMazeCnt = MazeCnt;
  271.       MazeDisp();
  272.       return 0;
  273.     }
  274.     case 3: {
  275.       if (*(char *)0x0800 != 0x02) GameStatus = 4;
  276.       return 0;
  277.     }
  278.     case 4: {
  279.       if (*(char *)0x0800 == 0x02) GameStatus = 5;
  280.       return 0;
  281.     }
  282.     case 5: {
  283.       if (*(char *)0x0800 != 0x02) GameStatus = 1;
  284.       return 0;
  285.     }
  286.     case 6: {
  287.       if (!BgmFlag) if (!Bgm(3)) Term();
  288.       BgmFlag = 1;
  289.       MyChrDead();
  290.       MyLeft--;
  291.       if (MyLeft < 0) GameStatus = 7;
  292.       My->X = My->InitX;
  293.       My->Y = My->InitY;
  294.       if (GameStatus != 7) {
  295.         Enemy = Start->Next;
  296.         while (Enemy->Next != NULL) {
  297.           Enemy->X = Enemy->InitX;
  298.           Enemy->Y = Enemy->InitY;
  299.           Enemy->Houkou  = 0;
  300.           Enemy->Cnt     = 0;
  301.           Enemy->DownCnt = 0;
  302.           Enemy = Enemy->Next;
  303.         }
  304.       }
  305.  
  306.       GatePtr = GateStart->Next;
  307.       while (GatePtr->Next != NULL) {
  308.         GatePtr->Status   = 5;
  309.         GatePtr->OpenFlag = 0;
  310.         GatePtr           = GatePtr->Next;
  311.       }
  312.       BgmFlag=0;
  313.       return 0;
  314.     }
  315.     case 7: {
  316.       SpInit();
  317.       (_Sprite *)sp = (_Sprite *)Sprite;
  318.       GameOver();
  319.       ScoreDisp();
  320.       EnemyMain();
  321.       Gate();
  322.       EnemyMain();
  323.       DispSprite();
  324.       i=0;
  325.       while (i<120) {
  326.         WaitVDisp();
  327.         i++;
  328.       }
  329.       GatePtr = GateStart->Next;
  330.       while (GatePtr->Next != NULL) {
  331.         Dummy    = GatePtr;
  332.         GatePtr->Prev->Next = GatePtr->Next;
  333.         GatePtr->Next->Prev = GatePtr->Prev;
  334.         GatePtr  = GatePtr->Next;
  335.         free(Dummy);
  336.       }
  337.       Enemy = Start->Next;
  338.       while (Enemy->Next != NULL) {
  339.         EnemyDummy        = Enemy;
  340.         Enemy->Prev->Next = Enemy->Next;
  341.         Enemy->Next->Prev = Enemy->Prev;
  342.         Enemy             = Enemy->Next;
  343.         free(EnemyDummy);
  344.       }
  345.       GameStatus = 0;
  346.       return 0;
  347.     }
  348.   }
  349.   return 0;
  350. }
  351.  
  352. static void
  353. StageClear(void)
  354. {
  355.   int i=0;
  356.   unsigned short Ptn;
  357.  
  358.   while (i<80) {
  359.     SpInit();
  360.     (_Sprite *)sp = (_Sprite *)Sprite;
  361.  
  362.     if ((i%20)<10) {
  363.       Ptn=0x0129;
  364.     } else {
  365.       Ptn=0x012A;
  366.     }
  367.  
  368.     sp->X   = My->X;
  369.     sp->Y   = My->Y;
  370.     sp->Ptn = Ptn+0x10;
  371.     sp->Pri = 3;
  372.     sp++;
  373.     sp->X   = My->X;
  374.     sp->Y   = My->Y-16;
  375.     sp->Ptn = Ptn;
  376.     sp->Pri = 3;
  377.     sp++;
  378.  
  379.     Gate();
  380.     ScoreDisp();
  381.  
  382.     DispSprite();
  383.     i++;
  384.   }
  385.   
  386.   for (i=0;i<30;i++) {
  387.     WaitVDisp();
  388.   }
  389. }
  390.  
  391. static void
  392. MyChrDead(void)
  393. {
  394.   int i=0;
  395.   unsigned short Ptn;
  396.  
  397.   while (i<60) {
  398.     SpInit();
  399.     (_Sprite *)sp = (_Sprite *)Sprite;
  400.  
  401.     if ((i%20)<10) {
  402.       Ptn=0x012B;
  403.     } else {
  404.       Ptn=0x012C;
  405.     }
  406.  
  407.     sp->X   = My->X;
  408.     sp->Y   = My->Y;
  409.     sp->Ptn = Ptn+0x10;
  410.     sp->Pri = 3;
  411.     sp++;
  412.     sp->X   = My->X;
  413.     sp->Y   = My->Y-16;
  414.     sp->Ptn = Ptn;
  415.     sp->Pri = 3;
  416.     sp++;
  417.  
  418.     EnemyMain();
  419.     Gate();
  420.     ScoreDisp();
  421.  
  422.     DispSprite();
  423.     i++;
  424.   }
  425.   GameStatus = 1;
  426. }
  427.  
  428.  
  429. static void
  430. ScoreDisp()
  431. {
  432.   unsigned char i;
  433.   unsigned int  Point;
  434.   unsigned int  Temp;
  435.   unsigned int  DummyScore;
  436.   char          DummyLeft;
  437.  
  438.   sp->X   = 16+8;
  439.   sp->Y   = 256;
  440.   sp->Ptn = 0x040A;
  441.   sp->Pri = 3;
  442.   sp++;
  443.   sp->X   = 32+8;
  444.   sp->Y   = 256;
  445.   sp->Ptn = 0x040B;
  446.   sp->Pri = 3;
  447.   sp++;
  448.  
  449.   sp->X   = 128;
  450.   sp->Y   = 256;
  451.   sp->Ptn = 0x040C;
  452.   sp->Pri = 3;
  453.   sp++;
  454.   sp->X   = 144;
  455.   sp->Y   = 256;
  456.   sp->Ptn = 0x040D;
  457.   sp->Pri = 3;
  458.   sp++;
  459.  
  460.   sp->X   = 216;
  461.   sp->Y   = 256;
  462.   sp->Ptn = 0x040E;
  463.   sp->Pri = 3;
  464.   sp++;
  465.   sp->X   = 232;
  466.   sp->Y   = 256;
  467.   sp->Ptn = 0x040F;
  468.   sp->Pri = 3;
  469.   sp++;
  470.  
  471.   i=0;
  472.   Point = 1000000;
  473.   DummyScore = Score;
  474.   while (i<7) {
  475.     if (DummyScore >= Point) {
  476.        Temp       = DummyScore/Point;
  477.        DummyScore -= (Temp*Point);
  478.        sp->X      = 48+(i*8)+8;
  479.        sp->Y      = 256;
  480.        sp->Ptn    = 0x0414+Temp;
  481.        sp->Pri    = 3;
  482.        sp++;
  483.     } else {
  484.        sp->X      = 48+(i*8)+8;
  485.        sp->Y      = 256;
  486.        sp->Ptn    = 0x0414;
  487.        sp->Pri    = 3;
  488.        sp++;
  489.     }
  490.     Point = Point / 10;
  491.     i++;
  492.   }
  493.  
  494.   if (Score > HiScore) HiScore = Score;
  495.   if (Score > ExtendEvery) {
  496.      ExtendEvery *=2;
  497.      MyLeft++;
  498.   }
  499.   i=0;
  500.   Point = 1000000;
  501.   DummyScore = HiScore;
  502.   while (i<7) {
  503.     if (DummyScore >= Point) {
  504.        Temp       = DummyScore/Point;
  505.        DummyScore -= (Temp*Point);
  506.        sp->X      = 160+(i*8);
  507.        sp->Y      = 256;
  508.        sp->Ptn    = 0x0414+Temp;
  509.        sp->Pri    = 3;
  510.        sp++;
  511.     } else {
  512.        sp->X   = 160+(i*8);
  513.        sp->Y   = 256;
  514.        sp->Ptn = 0x0414;
  515.        sp->Pri = 3;
  516.        sp++;
  517.     }
  518.     Point = Point / 10;
  519.     i++;
  520.   }
  521.   
  522.  
  523.   i=0;
  524.   Point = 10;
  525.   DummyLeft = MyLeft;
  526.   if (DummyLeft < 0) DummyLeft = 0; /*・・・適当な処理*/
  527.   while (i<2) {
  528.     if (DummyLeft >= Point) {
  529.        Temp       = DummyLeft/Point;
  530.        DummyLeft -= (Temp*Point);
  531.        sp->X      = 248+(i*8);
  532.        sp->Y      = 256;
  533.        sp->Ptn    = 0x0414+Temp;
  534.        sp->Pri    = 3;
  535.        sp++;
  536.     } else {
  537.        sp->X      = 248+(i*8);
  538.        sp->Y      = 256;
  539.        sp->Ptn    = 0x0414;
  540.        sp->Pri    = 3;
  541.        sp++;
  542.     }
  543.     Point = Point / 10;
  544.     i++;
  545.   }
  546.  
  547.  
  548. }
  549.  
  550. static void
  551. DispStage()
  552. {
  553.   unsigned char i;
  554.   unsigned int  Point;
  555.   unsigned int  Temp;
  556.   unsigned int  DummyStage;
  557.  
  558.   sp->X   = 112;
  559.   sp->Y   = 128;
  560.   sp->Ptn = 0x051E;
  561.   sp->Pri = 3;
  562.   sp++;
  563.   sp->X   = 128;
  564.   sp->Y   = 128;
  565.   sp->Ptn = 0x051F;
  566.   sp->Pri = 3;
  567.   sp++;
  568.  
  569.   i=0;
  570.   Point = 10;
  571.   DummyStage = GameStage;
  572.   while (i<2) {
  573.     if (DummyStage >= Point) {
  574.        Temp       = DummyStage/Point;
  575.        DummyStage -= (Temp*Point);
  576.        sp->X      = 144+(i*8);
  577.        sp->Y      = 128;
  578.        sp->Ptn    = 0x0414+Temp;
  579.        sp->Pri    = 3;
  580.        sp++;
  581.     } else {
  582.        sp->X      = 144+(i*8);
  583.        sp->Y      = 128;
  584.        sp->Ptn    = 0x0414;
  585.        sp->Pri    = 3;
  586.        sp++;
  587.     }
  588.     Point = Point / 10;
  589.     i++;
  590.   }
  591. }
  592.  
  593.  
  594.  
  595. static char
  596. Demo(void)
  597. {
  598.   int i;
  599.  
  600.   if (((*(char *)0xE9A001&0x40)==0) || ((*(char *)0xE9A001&0x20)==0)) {
  601.      PushAFlag = -1;
  602.   } else {
  603.      PushAFlag =  0;
  604.   }
  605.  
  606.   for (i=0;i<3;i++) {
  607.     sp->X   = 120+(i*16);
  608.     sp->Y   = 224;
  609.     sp->Ptn = 0x052d+i;
  610.     sp->Pri = 3;
  611.     sp++;
  612.   }
  613.   for (i=0;i<2;i++) {
  614.     sp->X   = 120+(i*16);
  615.     sp->Y   = 240;
  616.     sp->Ptn = 0x053d+i;
  617.     sp->Pri = 3;
  618.     sp++;
  619.   }
  620.   
  621.   if (ContinueCnt) {
  622.     for (i=0;i<3;i++) {
  623.       sp->X   = 120+(i*16);
  624.       sp->Y   = 208;
  625.       sp->Ptn = 0x0580+i;
  626.       sp->Pri = 3;
  627.       sp++;
  628.     }
  629.   
  630.     sp->X      = 168;
  631.     sp->Y      = 208;
  632.     sp->Ptn    = 0x0414+ContinueCnt;
  633.     sp->Pri    = 3;
  634.     sp++;
  635.   }
  636.   
  637.   if (PushFlag) {
  638.     if (((*(char *)0xE9A001&0x01)!=0) && ((*(char *)0xE9A001&0x02)!=0)) PushFlag = 0;
  639.   }
  640.  
  641.   if (((*(char  *)0xE9A001 & 0x01) == 0) && (!PushFlag) ) {
  642.     CursorY  -= 16;
  643.     if (CursorY < 224) {
  644.       if (ContinueCnt) { 
  645.         CursorY = 208;
  646.       } else {
  647.         CursorY = 240;
  648.       }
  649.     }
  650.     PushFlag = -1;
  651.   }
  652.  
  653.   if (((*(char  *)0xE9A001 & 0x02) == 0) && (!PushFlag) ) {
  654.     CursorY  += 16;
  655.     if (CursorY > 240 ) { 
  656.       if (ContinueCnt) {
  657.         CursorY = 208;
  658.       } else {
  659.         CursorY = 224;
  660.       }
  661.     }
  662.     PushFlag = -1;
  663.   }
  664.  
  665.   sp->X   = 104;
  666.   sp->Y   = CursorY;
  667.   sp->Ptn = 0x053F;
  668.   sp->Pri = 3;
  669.   sp++;
  670.  
  671.   ScoreDisp();
  672.   DispSprite();
  673.  
  674.  
  675.   if (!BgmFlag) {
  676.     for (i=0;i<30;i++) {
  677.        WaitVDisp();
  678.     }
  679.     BgmFlag = 1;
  680.   }
  681.  
  682.  
  683.   if (CursorY == 208 || CursorY == 224) {
  684.     if (!PushAFlag) {
  685.       if (((*(char *)0xE9A001&0x40)==0) || ((*(char *)0xE9A001&0x20)==0)) {
  686.         GameStatus   = 1;
  687.         /*GameStage    = 1;*/
  688.         BgmFlag      = 0;
  689.         MyLeft       = 2;
  690.         Score        = 0;
  691.         ExtendEvery  = 10000;
  692.         EnemyCnt     = 0;
  693.       
  694.         if (CursorY == 224) {
  695.           ContinueMazeCnt = MazeCnt;
  696.           ContinueCnt     = 3;
  697.           GameStage       = 1;
  698.         }
  699.         if (CursorY == 208) {
  700.           MazeCnt      = ContinueMazeCnt;
  701.           ContinueCnt -= 1;
  702.         }
  703.     
  704.         MazeDisp();
  705.       }
  706.     }
  707.   }
  708.   
  709.   
  710.   
  711.   if (CursorY == 240) {
  712.     if (!PushAFlag) {
  713.       if (((*(char *)0xE9A001&0x40)==0) || ((*(char *)0xE9A001&0x20)==0)) {
  714.         return -1;
  715.       }
  716.     }
  717.   }
  718.  
  719.   return 0;
  720. }
  721.  
  722. static void
  723. GameOver(void)
  724. {
  725.   short i;
  726.  
  727.   for (i=0;i<2;i++) {
  728.     sp->X   = 120+(i*16);
  729.     sp->Y   = 128;
  730.     sp->Ptn = 0x054E+i;
  731.     sp->Pri = 3;
  732.     sp++;
  733.     sp->X   = 152+(i*16);
  734.     sp->Y   = 128;
  735.     sp->Ptn = 0x055E+i;
  736.     sp->Pri = 3;
  737.     sp++;
  738.   }
  739.  
  740. }
  741.  
  742. static void
  743. MazeDisp(void)
  744. {
  745.   short i,j;
  746.   char  LoopFlag;
  747.  
  748.   for (i=0;i<15;i++) {
  749.     for (j=0;j<15;j++) {
  750.        LoopFlag=0;
  751.        
  752.        while (!LoopFlag) {
  753.          switch (MazePtr[MazeCnt]) {
  754.            case  0x21: {
  755.               Ending();
  756.               Term();
  757.            }
  758.            case  0x30: {
  759.               TileDraw(i,j);
  760.               LoopFlag = -1;
  761.               MazeCnt++;
  762.               break;
  763.            }
  764.            case  0x31: {
  765.               BlockDraw(i,j);
  766.               LoopFlag = -1;
  767.               MazeCnt++;
  768.               break;
  769.            }
  770.            case  0x4d: {
  771.               if (!CreateEnemy(i,j,0)) {
  772.                 printf("敵キャラのメモリの確保に失敗しました\n");
  773.                 Term(); /* Abort */
  774.               }
  775.               TileDraw(i,j);
  776.               LoopFlag = -1;
  777.               MazeCnt++;
  778.               break;
  779.            }
  780.            case  0x4e: {
  781.               if (!CreateEnemy(i,j,1)) {
  782.                 printf("敵キャラのメモリの確保に失敗しました\n");
  783.                 Term(); /* Abort */
  784.               }
  785.               TileDraw(i,j);
  786.               LoopFlag = -1;
  787.               MazeCnt++;
  788.               break;
  789.            }
  790.            case  0x47: {
  791.               if (!CreateGate(i,j)) {
  792.                 printf("ゲートのメモリの確保に失敗しました\n");
  793.                 Term(); /* Abort */
  794.               }
  795.               TileDraw(i,j);
  796.               LoopFlag = -1;
  797.               MazeCnt++;
  798.               break;
  799.            }
  800.             case  0x52: {
  801.               TileDraw(i,j);
  802.               My->X      = j*16+16+8;
  803.               My->Y      = i*16+16;
  804.               My->InitX  = j*16+16+8;
  805.               My->InitY  = i*16+16;
  806.               My->Houkou = 0;
  807.               My->Cnt    = 0;
  808.               LoopFlag = -1;
  809.               MazeCnt++;
  810.               break;
  811.            }
  812.            default:
  813.              if ((0x80 <= MazePtr[MazeCnt] && MazePtr[MazeCnt] <= 0x9F)
  814.               || (0xE0 <= MazePtr[MazeCnt] && MazePtr[MazeCnt] <= 0xFE)) {
  815.                MazeCnt+=2;
  816.              } else {
  817.                MazeCnt++;
  818.              }
  819.          }
  820.        }
  821.     }
  822.   }
  823. }
  824.  
  825. static void
  826. Ending()
  827. {
  828.   int i=0;
  829.  
  830.   while (i<60) {
  831.     WaitVDisp();
  832.     i++;
  833.   }
  834.   CRTMOD(16);
  835.   G_CLR_ON();
  836.   B_CURON();
  837.   
  838.   
  839.   printf("ここまで、遊んでくれた方達に心から感謝します。\n\n");
  840.   printf("さて、今回の「ＲＯＳＡ・ＲＯＳＡ」は、いかがでしたでしょうか？\n\n");
  841.   printf("楽しんでいただけたなら、幸いです\n\n");
  842.   printf("次は、シューティング・ゲームを公開する予定です。\n\n");
  843.   printf("楽しみにして戴けたら、うれしいです。\n\n\n");
  844.   printf("1997/09/25  Miyamori-Toshimi. & NKGR\n\n");
  845.  
  846.  
  847. }
  848.  
  849. static void
  850. BlockDraw(short i,short j)
  851. {
  852.    short *Addr ;
  853.  
  854.    (short *)Addr = 0xEBE000;
  855.  
  856.    (short *)Addr += (i*2) * 64 + (j*2) + 1;
  857.  
  858.    *(short *)Addr      = 0x0204;
  859.    *(short *)(Addr+1)  = 0x0206;
  860.    *(short *)(Addr+64) = 0x0205;
  861.    *(short *)(Addr+65) = 0x0207;
  862. }
  863. static void
  864. TileDraw(short i,short j)
  865. {
  866.    short *Addr ;
  867.  
  868.    (short *)Addr = 0xEBE000;
  869.  
  870.    (short *)Addr += (i*2) * 64 + (j*2) + 1;
  871.  
  872.    *(short *)Addr      = 0x0208;
  873.    *(short *)(Addr+1)  = 0x020A;
  874.    *(short *)(Addr+64) = 0x0209;
  875.    *(short *)(Addr+65) = 0x020B;
  876.  
  877. }
  878. static char
  879. MyInit(void)
  880. {
  881.   (_MyChr *)My = (_MyChr *)malloc(sizeof(_MyChr));
  882.   if (My == NULL)  return 0;
  883.   return -1;
  884. }
  885.  
  886. static void
  887. MyChrMove()
  888. {
  889.   unsigned short *Addr;
  890.   unsigned short Ptn;
  891.   unsigned char  OldHoukou;
  892.  
  893.   char KeyPort = *(char *)0xE9A001;
  894.  
  895.   OldHoukou=My->Houkou;
  896.  
  897.  
  898.   if ( (((My->X-8) % 16) == 0) 
  899.     && ( (My->Y % 16) == 0) ) {
  900.  
  901.      My->UpFlag    = 0;
  902.      My->DownFlag  = 0;
  903.      My->LeftFlag  = 0;
  904.      My->RightFlag = 0;
  905.      My->Houkou    = 0;
  906.  
  907.      (unsigned short *)Addr = (unsigned short *)0xEBE002+((My->Y-16)/8)*64+((My->X-24)/8);
  908.  
  909.      if (*(short *)(Addr-64)  > 0x0207 && *(short *)(Addr-63) > 0x0207) My->UpFlag     = 1;
  910.      if (*(short *)(Addr+128) > 0x0207 && *(short *)(Addr+129)> 0x0207) My->DownFlag   = 1;
  911.      if (*(short *)(Addr-1)   > 0x0207 && *(short *)(Addr+63) > 0x0207) My->LeftFlag   = 1;
  912.      if (*(short *)(Addr+2)   > 0x0207 && *(short *)(Addr+66) > 0x0207) My->RightFlag  = 1;
  913.   }
  914.  
  915.   if (((My->X-8) % 16) == 0) {
  916.     if (OldHoukou > 2) {
  917.       if ( ((KeyPort & 0x01) == 0) && (My->UpFlag    == 1) ) My->Houkou = 1;
  918.       if ( ((KeyPort & 0x02) == 0) && (My->DownFlag  == 1) ) My->Houkou = 2;
  919.     }
  920.   }
  921.   if ((My->Y % 16) == 0) {
  922.     if (OldHoukou < 3) {
  923.       if ( ((KeyPort & 0x04) == 0) && (My->LeftFlag  == 1) ) My->Houkou = 3;
  924.       if ( ((KeyPort & 0x08) == 0) && (My->RightFlag == 1) ) My->Houkou = 4;
  925.     }
  926.   }
  927.  
  928.   if (My->Houkou == 1 || !My->Houkou) {
  929.     if (((My->X-8) % 16) == 0) {
  930.       if ( ((KeyPort & 0x02) == 0) && (My->DownFlag  == 1) ) My->Houkou = 2;
  931.     }
  932.   }
  933.   if (My->Houkou == 2 || !My->Houkou) {
  934.     if (((My->X-8) % 16) == 0) {
  935.       if ( ((KeyPort & 0x01) == 0) && (My->UpFlag  == 1) ) My->Houkou = 1;
  936.     }
  937.   }
  938.   if (My->Houkou == 3 || !My->Houkou) {
  939.     if ((My->Y % 16) == 0) {
  940.       if ( ((KeyPort & 0x08) == 0) && (My->RightFlag  == 1) ) My->Houkou = 4;
  941.     }
  942.   }
  943.   if (My->Houkou == 4 || !My->Houkou) {
  944.     if ((My->Y % 16) == 0) {
  945.       if ( ((KeyPort & 0x04) == 0) && (My->LeftFlag  == 1) ) My->Houkou = 3;
  946.     }
  947.   }
  948.  
  949.   if (My->Houkou == 1) My->Y--;
  950.   if (My->Houkou == 2) My->Y++;
  951.   if (My->Houkou == 3) My->X--;
  952.   if (My->Houkou == 4) My->X++;
  953.  
  954.   My->Cnt++;
  955.   if (My->Cnt == 28)  My->Cnt = 0;
  956.  
  957.   if (My->Houkou == 1)  Ptn=0x0120+(My->Cnt/4);
  958.   if (My->Houkou == 2)  Ptn=0x0140+(My->Cnt/4);
  959.   if (My->Houkou == 3)  Ptn=0x0160+(My->Cnt/4);
  960.   if (My->Houkou == 4)  Ptn=0x0147+(My->Cnt/4);
  961.  
  962.   if (!My->Houkou)  Ptn=0x0127+(My->Cnt/14);
  963.  
  964.   sp->X   = My->X;
  965.   sp->Y   = My->Y;
  966.   sp->Ptn = Ptn+0x10;
  967.   sp->Pri = 3;
  968.   sp++;
  969.   sp->X   = My->X;
  970.   sp->Y   = My->Y-16;
  971.   sp->Ptn = Ptn;
  972.   sp->Pri = 3;
  973.   sp++;
  974.   
  975. }
  976.  
  977. static void
  978. DispSprite()
  979. {
  980.    volatile char *Reg;
  981.    int           i;
  982.    _Sprite       *Addr;
  983.  
  984.   (char *)Reg = 0xE88001;
  985.   while (!(*Reg & 0x10));
  986.   while ( (*Reg & 0x10));
  987.  
  988.   (_Sprite *)Addr = 0xEB0000;
  989.   (_Sprite *)sp   = (_Sprite *)Sprite;
  990.  
  991.   for (i=0;i<128;i++) {
  992.     *(_Sprite *)Addr++  = *(_Sprite *)sp++;
  993.   }
  994. }
  995.  
  996.  
  997. static void
  998. WaitVDisp(void)
  999. {
  1000.    volatile char *Reg;
  1001.  
  1002.   (char *)Reg = 0xE88001;
  1003.   while (!(*Reg & 0x10));
  1004.   while ( (*Reg & 0x10));
  1005. }
  1006.  
  1007.  
  1008. static char
  1009. MazeLoad(void)
  1010. {
  1011.   FILE *FilePtr;
  1012.   int Size;
  1013.  
  1014.   FilePtr = fopen("MazeData.Dat","rt");
  1015.  
  1016.   if (FilePtr != NULL) {
  1017.      Size = filelength(fileno(FilePtr));
  1018.      if (((unsigned char *)MazePtr=(unsigned char *)malloc(Size)) == NULL) {
  1019.         printf("マップ・データのメモリの確保に失敗しました\n");
  1020.         fclose(FilePtr);
  1021.         return 0;
  1022.      } else {
  1023.         fread(MazePtr,1,filelength(fileno(FilePtr)),FilePtr);
  1024.         fclose(FilePtr);
  1025.         return -1;
  1026.      }
  1027.   } else {
  1028.     printf("マップ・データの読み込みに失敗しました。\n");
  1029.     return 0;
  1030.   }
  1031. }
  1032.  
  1033. static char
  1034. CreateEnemy(short i, short j,char Type)
  1035. {
  1036.   _Enemy  *Enemy;
  1037.  
  1038.   if  ( ((_Enemy *)Enemy=(_Enemy *)malloc(sizeof(_Enemy))) == NULL ) return 0;
  1039.  
  1040.   Enemy->Next        = Start->Next;
  1041.   Enemy->Prev        = Start;
  1042.   Enemy->Prev->Next  = Enemy;
  1043.   Enemy->Next->Prev  = Enemy;
  1044.  
  1045.   Enemy->X       = j*16+16+8;
  1046.   Enemy->Y       = i*16+16;
  1047.   Enemy->InitX   = j*16+16+8;
  1048.   Enemy->InitY   = i*16+16;
  1049.   Enemy->Type    = Type;
  1050.   Enemy->Houkou  = 0;
  1051.   Enemy->Cnt     = 0;
  1052.   Enemy->DownCnt = 0;
  1053.  
  1054.   EnemyCnt ++;
  1055.  
  1056.   return -1;
  1057. }
  1058.  
  1059. static char
  1060. EnemyInit(void)
  1061. {
  1062.   if  ( ((_Enemy *)Start=(_Enemy *)malloc(sizeof(_Enemy))) == NULL ) {
  1063.       printf("敵キャラＳＴＡＲＴメモリの確保に失敗しました\n");
  1064.       return 0;
  1065.   }
  1066.   if  ( ((_Enemy *)End=(_Enemy *)malloc(sizeof(_Enemy))) == NULL ) { 
  1067.       printf("敵キャラＥＮＤメモリの確保に失敗しました\n");
  1068.       return 0;
  1069.   }
  1070.   
  1071.   Start->Prev = NULL;
  1072.   Start->Next = End;
  1073.   End->Prev   = Start;
  1074.   End->Next   = NULL;
  1075.  
  1076.   return -1;
  1077. }
  1078.  
  1079. static char
  1080. GateInit(void)
  1081. {
  1082.   if  ( ((_Gate *)GateStart=(_Gate *)malloc(sizeof(_Gate))) == NULL ) {
  1083.       printf("ゲートＳＴＡＲＴメモリの確保に失敗しました\n");
  1084.       return 0;
  1085.   }
  1086.   if  ( ((_Gate *)GateEnd=(_Gate *)malloc(sizeof(_Gate))) == NULL ) { 
  1087.       printf("ゲートＥＮＤメモリの確保に失敗しました\n");
  1088.       return 0;
  1089.   }
  1090.   
  1091.   GateStart->Prev = NULL;
  1092.   GateStart->Next = GateEnd;
  1093.   GateEnd->Prev   = GateStart;
  1094.   GateEnd->Next   = NULL;
  1095.  
  1096.   return -1;
  1097. }
  1098.  
  1099. static void
  1100. EnemyMain(void)
  1101. {
  1102.   _Enemy  *Enemy;
  1103.   char    PcmFlag=0;
  1104.  
  1105.   EnemyDownFlag = 0;
  1106.  
  1107.  
  1108.   Enemy = Start->Next;
  1109.  
  1110.   while ( Enemy->Next != NULL ) {
  1111.  
  1112.     if (!Enemy->DownCnt) {
  1113.       if ( !Enemy->Type )  {
  1114.         EnemyOikake1(Enemy);
  1115.       } else {
  1116.         EnemyOikake2(Enemy);
  1117.       }
  1118.       if ((My->X < (Enemy->X+8)) && ((My->X+8) > Enemy->X)
  1119.        && (My->Y < (Enemy->Y+8)) && ((My->Y+8) > Enemy->Y))  GameStatus = 6;
  1120.     } else {
  1121.       Enemy->DownCnt--;
  1122.       if (!Enemy->DownCnt) {
  1123.          if (!PcmFlag) { 
  1124.            Se(4);
  1125.            PcmFlag = -1;
  1126.          }
  1127.       }
  1128.       Enemy->Cnt++;
  1129.       if (Enemy->Cnt == 28) Enemy->Cnt = 0;
  1130.       sp->X   = Enemy->X;
  1131.       sp->Y   = Enemy->Y-8;
  1132.       sp->Ptn = 0x0310+(Enemy->Cnt/7);
  1133.       sp->Pri = 3;
  1134.       sp++;
  1135.     }
  1136.     Enemy = Enemy->Next;
  1137.   }
  1138. }
  1139.  
  1140. static void
  1141. EnemyOikake1(_Enemy *Enemy)
  1142. {
  1143.   char UpFlag    = 0;
  1144.   char DownFlag  = 0;
  1145.   char LeftFlag  = 0;
  1146.   char RightFlag = 0;
  1147.   char OldHoukou = Enemy->Houkou;
  1148.   char MoveCnt   = 0;
  1149.   short *Addr;
  1150.  
  1151.   short Ptn=0x0669;
  1152.  
  1153.  _Gate *Gate;
  1154.  
  1155.   Enemy->Cnt ++;
  1156.   if (Enemy->Cnt == 28) Enemy->Cnt = 0;
  1157.   if (!(Enemy->Cnt%2) && (GameStatus == 1)) {
  1158.  
  1159.     if ( (((Enemy->X-8) % 16) == 0) && ( (Enemy->Y % 16) == 0) ) {
  1160.        (unsigned short *)Addr = (unsigned short *)0xEBE002+((Enemy->Y-16)/8)*64+((Enemy->X-24)/8);
  1161.        Enemy->Houkou = 0;
  1162.        if (*(short *)(Addr-64)  > 0x0207 && *(short *)(Addr-63) > 0x0207) {
  1163.          UpFlag     = 1;
  1164.          MoveCnt++;
  1165.        } 
  1166.        if (*(short *)(Addr+128) > 0x0207 && *(short *)(Addr+129)> 0x0207) {
  1167.          DownFlag   = 1;
  1168.          MoveCnt++;
  1169.        }
  1170.        if (*(short *)(Addr-1)   > 0x0207 && *(short *)(Addr+63) > 0x0207) {
  1171.          LeftFlag   = 1;
  1172.          MoveCnt++;
  1173.        }
  1174.        if (*(short *)(Addr+2)   > 0x0207 && *(short *)(Addr+66) > 0x0207) {
  1175.          RightFlag  = 1;
  1176.          MoveCnt++;
  1177.        }
  1178.        if (MoveCnt > 1) {
  1179.          if (OldHoukou == 3 || OldHoukou == 4 || !OldHoukou) {
  1180.            if ((UpFlag     == 1) && (My->Y < Enemy->Y))  Enemy->Houkou = 1;
  1181.            if ((DownFlag   == 1) && (My->Y > Enemy->Y))  Enemy->Houkou = 2;
  1182.          }
  1183.  
  1184.          if (OldHoukou == 1 || OldHoukou == 2 || !OldHoukou) {
  1185.            if ((LeftFlag   == 1) && (My->X < Enemy->X))  Enemy->Houkou = 3;
  1186.            if ((RightFlag  == 1) && (My->X > Enemy->X))  Enemy->Houkou = 4;
  1187.          }
  1188.          if (!Enemy->Houkou) {
  1189.            if (OldHoukou == 1  && UpFlag)    Enemy->Houkou = 1;
  1190.            if (OldHoukou == 2  && DownFlag)  Enemy->Houkou = 2;
  1191.            if (OldHoukou == 3  && LeftFlag)  Enemy->Houkou = 3;
  1192.            if (OldHoukou == 4  && RightFlag) Enemy->Houkou = 4;
  1193.          }
  1194.          if (!Enemy->Houkou) {
  1195.            if (OldHoukou == 1  && RightFlag)  Enemy->Houkou = 4;
  1196.            if (OldHoukou == 4  && DownFlag)   Enemy->Houkou = 2;
  1197.            if (OldHoukou == 2  && LeftFlag)   Enemy->Houkou = 3;
  1198.            if (OldHoukou == 3  && UpFlag)     Enemy->Houkou = 1;
  1199.          }
  1200.          if (!Enemy->Houkou) {
  1201.            if (RightFlag)                    Enemy->Houkou = 4;
  1202.            if (!Enemy->Houkou && DownFlag)   Enemy->Houkou = 2;
  1203.            if (!Enemy->Houkou && LeftFlag)   Enemy->Houkou = 3;
  1204.            if (!Enemy->Houkou && UpFlag)     Enemy->Houkou = 1;
  1205.          }
  1206.        } else {
  1207.          if (OldHoukou == 1 || (!Enemy->Houkou && DownFlag))  Enemy->Houkou = 2;
  1208.          if (OldHoukou == 2 || (!Enemy->Houkou && UpFlag))    Enemy->Houkou = 1;
  1209.          if (OldHoukou == 3 || (!Enemy->Houkou && RightFlag)) Enemy->Houkou = 4;
  1210.          if (OldHoukou == 4 || (!Enemy->Houkou && LeftFlag))  Enemy->Houkou = 3;
  1211.        }
  1212.     }
  1213.  
  1214.     if (Enemy->Houkou == 1) Enemy->Y -= 1;
  1215.     if (Enemy->Houkou == 2) Enemy->Y += 1;
  1216.     if (Enemy->Houkou == 3) Enemy->X -= 1;
  1217.     if (Enemy->Houkou == 4) Enemy->X += 1;
  1218.  
  1219.     Gate     = GateStart->Next;
  1220.     while (Gate->Next != NULL) {
  1221.       if (Gate->X == Enemy->X && Gate->Y == Enemy->Y && Gate->OpenFlag == 2) {
  1222.         if (!EnemyDownFlag) {
  1223.           Se(3);
  1224.           EnemyDownFlag = -1;
  1225.         }
  1226.         Enemy->Cnt     = 0;
  1227.         Enemy->DownCnt = 350;
  1228.         break;
  1229.       }
  1230.       Gate=Gate->Next;
  1231.     }
  1232.   }
  1233.  
  1234.   if (Enemy->Houkou == 1) Ptn=0x066D;
  1235.   if (Enemy->Houkou == 2) Ptn=0x0669;
  1236.   if (Enemy->Houkou == 3) Ptn=0x0667;
  1237.   if (Enemy->Houkou == 4) Ptn=0x066B;
  1238.  
  1239.   sp->X   = Enemy->X;
  1240.   sp->Y   = Enemy->Y;
  1241.   sp->Ptn = Ptn+((Enemy->Cnt/14));
  1242.   sp->Pri = 3;
  1243.   sp++;
  1244. }
  1245. static void
  1246. EnemyOikake2(_Enemy *Enemy)
  1247. {
  1248.   char UpFlag    = 0;
  1249.   char DownFlag  = 0;
  1250.   char LeftFlag  = 0;
  1251.   char RightFlag = 0;
  1252.   char OldHoukou = Enemy->Houkou;
  1253.   char MoveCnt   = 0;
  1254.   short *Addr;
  1255.  
  1256.   short Ptn=0x0779;
  1257.  
  1258.   _Gate  *Gate;
  1259.  
  1260.   Enemy->Cnt ++;
  1261.   if (Enemy->Cnt == 28) Enemy->Cnt = 0;
  1262.   if (!(Enemy->Cnt%2) && (GameStatus == 1)) {
  1263.  
  1264.     if ( (((Enemy->X-8) % 16) == 0) && ( (Enemy->Y % 16) == 0) ) {
  1265.        (unsigned short *)Addr = (unsigned short *)0xEBE002+((Enemy->Y-16)/8)*64+((Enemy->X-24)/8);
  1266.        Enemy->Houkou = 0;
  1267.        if (*(short *)(Addr-64)  > 0x0207 && *(short *)(Addr-63) > 0x0207) {
  1268.          UpFlag     = 1;
  1269.          MoveCnt++;
  1270.        } 
  1271.        if (*(short *)(Addr+128) > 0x0207 && *(short *)(Addr+129)> 0x0207) {
  1272.          DownFlag   = 1;
  1273.          MoveCnt++;
  1274.        }
  1275.        if (*(short *)(Addr-1)   > 0x0207 && *(short *)(Addr+63) > 0x0207) {
  1276.          LeftFlag   = 1;
  1277.          MoveCnt++;
  1278.        }
  1279.        if (*(short *)(Addr+2)   > 0x0207 && *(short *)(Addr+66) > 0x0207) {
  1280.          RightFlag  = 1;
  1281.          MoveCnt++;
  1282.        }
  1283.        if (MoveCnt > 1) {
  1284.          if (OldHoukou == 3 || OldHoukou == 4 || !OldHoukou) {
  1285.            if ((UpFlag     == 1) && (My->Y < Enemy->Y))  Enemy->Houkou = 1;
  1286.            if ((DownFlag   == 1) && (My->Y > Enemy->Y))  Enemy->Houkou = 2;
  1287.          }
  1288.  
  1289.          if (OldHoukou == 1 || OldHoukou == 2 || !OldHoukou) {
  1290.            if ((LeftFlag   == 1) && (My->X < Enemy->X))  Enemy->Houkou = 3;
  1291.            if ((RightFlag  == 1) && (My->X > Enemy->X))  Enemy->Houkou = 4;
  1292.          }
  1293.          if (!Enemy->Houkou) {
  1294.            if (OldHoukou == 1  && UpFlag)     Enemy->Houkou = 1;
  1295.            if (OldHoukou == 2  && DownFlag)   Enemy->Houkou = 2;
  1296.            if (OldHoukou == 3  && LeftFlag)   Enemy->Houkou = 3;
  1297.            if (OldHoukou == 4  && RightFlag)  Enemy->Houkou = 4;
  1298.          }
  1299.          if (!Enemy->Houkou) {
  1300.            if (OldHoukou == 1  && LeftFlag)   Enemy->Houkou = 3;
  1301.            if (OldHoukou == 3  && DownFlag)   Enemy->Houkou = 2;
  1302.            if (OldHoukou == 2  && RightFlag)  Enemy->Houkou = 4;
  1303.            if (OldHoukou == 4  && UpFlag)     Enemy->Houkou = 1;
  1304.          }
  1305.          if (!Enemy->Houkou) {
  1306.            if (LeftFlag)                      Enemy->Houkou = 3;
  1307.            if (!Enemy->Houkou && DownFlag)    Enemy->Houkou = 2;
  1308.            if (!Enemy->Houkou && RightFlag)   Enemy->Houkou = 4;
  1309.            if (!Enemy->Houkou && UpFlag)      Enemy->Houkou = 1;
  1310.          }
  1311.        } else {
  1312.          if (OldHoukou == 1 || (!Enemy->Houkou && DownFlag))  Enemy->Houkou = 2;
  1313.          if (OldHoukou == 2 || (!Enemy->Houkou && UpFlag))    Enemy->Houkou = 1;
  1314.          if (OldHoukou == 3 || (!Enemy->Houkou && RightFlag)) Enemy->Houkou = 4;
  1315.          if (OldHoukou == 4 || (!Enemy->Houkou && LeftFlag))  Enemy->Houkou = 3;
  1316.        }
  1317.     }
  1318.  
  1319.     if (Enemy->Houkou == 1) Enemy->Y -= 1;
  1320.     if (Enemy->Houkou == 2) Enemy->Y += 1;
  1321.     if (Enemy->Houkou == 3) Enemy->X -= 1;
  1322.     if (Enemy->Houkou == 4) Enemy->X += 1;
  1323.  
  1324.     Gate     = GateStart->Next;
  1325.     while (Gate->Next != NULL) {
  1326.       if (Gate->X == Enemy->X && Gate->Y == Enemy->Y && Gate->OpenFlag == 2) {
  1327.         if (!EnemyDownFlag) {
  1328.           Se(3);
  1329.           EnemyDownFlag = -1;
  1330.         }
  1331.         Enemy->Cnt     = 0;
  1332.         Enemy->DownCnt = 350;
  1333.         break;
  1334.       }
  1335.       Gate=Gate->Next;
  1336.     }
  1337.   }
  1338.  
  1339.   if (Enemy->Houkou == 1) Ptn=0x077D;
  1340.   if (Enemy->Houkou == 2) Ptn=0x0779;
  1341.   if (Enemy->Houkou == 3) Ptn=0x0777;
  1342.   if (Enemy->Houkou == 4) Ptn=0x077B;
  1343.  
  1344.   sp->X   = Enemy->X;
  1345.   sp->Y   = Enemy->Y;
  1346.   sp->Ptn = Ptn+(Enemy->Cnt/14);
  1347.   sp->Pri = 3;
  1348.   sp++;
  1349. }
  1350.  
  1351. static char
  1352. CreateGate(short i,short j)
  1353. {
  1354.   _Gate  *Gate;
  1355.  
  1356.   if  ( ((_Gate *)Gate=(_Gate *)malloc(sizeof(_Gate))) == NULL ) return 0;
  1357.  
  1358.   Gate->Next        = GateStart->Next;
  1359.   Gate->Prev        = GateStart;
  1360.   Gate->Prev->Next  = Gate;
  1361.   Gate->Next->Prev  = Gate;
  1362.  
  1363.   Gate->X        = j*16+16+8;
  1364.   Gate->Y        = i*16+16;
  1365.   Gate->Status   = 5;
  1366.   Gate->OpenFlag = 0;
  1367.  
  1368.   return -1;
  1369. }
  1370.  
  1371. static void
  1372. Gate(void)
  1373. {
  1374.   _Gate  *Gate; 
  1375.   short  Ptn;
  1376.   _Enemy *Enemy,*Dummy;
  1377.  
  1378.   unsigned  int Cnt;
  1379.   char          PcmFlag = 0;
  1380.  
  1381.   Gate = GateStart->Next;
  1382.  
  1383.   while ( Gate->Next != NULL ) {
  1384.  
  1385. /* GateOpen */
  1386.     if (!Gate->OpenFlag) {
  1387.       if (Gate->Y == My->Y && (Gate->X < (My->X+16) && My->X < (Gate->X+16))) {
  1388.         Gate->Status = (Gate->X - My->X)/3;
  1389.         if (Gate->Status<0) Gate->Status *= -1;
  1390.       }
  1391.       if (Gate->X == My->X && (Gate->Y < (My->Y+16) && My->Y < (Gate->Y+16))) {
  1392.         Gate->Status = (Gate->Y - My->Y)/3;
  1393.         if (Gate->Status<0) Gate->Status *= -1;
  1394.       }
  1395.       if (Gate->X == My->X && Gate->Y == My->Y) { 
  1396.          Gate->OpenFlag = 1;
  1397.          Se(0);
  1398.       }
  1399.     }
  1400.  
  1401.     if (Gate->OpenFlag == 1) {
  1402.        if (Gate->X+15 < My->X) Gate->OpenFlag = 2;
  1403.        if (Gate->X-15 > My->X) Gate->OpenFlag = 2;
  1404.        if (Gate->Y+15 < My->Y) Gate->OpenFlag = 2;
  1405.        if (Gate->Y-15 > My->Y) Gate->OpenFlag = 2;
  1406.     }
  1407.  
  1408.     if (Gate->OpenFlag == 2) {
  1409.       if (Gate->Y == My->Y && (Gate->X < (My->X+16) && My->X < (Gate->X+16))) {
  1410.         Gate->Status = (Gate->X - My->X)/3;
  1411.         if (Gate->Status<0) Gate->Status *= -1;
  1412.         Gate->Status = 5 - Gate->Status;
  1413.       }
  1414.       if (Gate->X == My->X && (Gate->Y < (My->Y+16) && My->Y < (Gate->Y+16))) {
  1415.         Gate->Status = (Gate->Y - My->Y)/3;
  1416.         if (Gate->Status<0) Gate->Status *= -1;
  1417.         Gate->Status = 5 - Gate->Status;
  1418.       }
  1419.       if (Gate->X == My->X && Gate->Y == My->Y) {
  1420.          Gate->OpenFlag = 3;
  1421.          Se(1);
  1422.       }
  1423.     } 
  1424.  
  1425.     if (Gate->OpenFlag == 3) {
  1426.        Cnt=1;
  1427.        Enemy = Start->Next;
  1428.        while (Enemy->Next != NULL) {
  1429.          if (Gate->X == Enemy->X && Gate->Y == Enemy->Y && Enemy->DownCnt) {
  1430. /*         if (!PcmFlag) {
  1431.              Se(2);
  1432.              PcmFlag = -1;
  1433.            }
  1434. */
  1435.            Dummy = Enemy;
  1436.            Enemy->Prev->Next = Enemy->Next;
  1437.            Enemy->Next->Prev = Enemy->Prev;
  1438.            Enemy = Enemy->Next;
  1439.            free(Dummy);
  1440.            Gate->OpenFlag = 4;
  1441.            EnemyCnt--;
  1442.            
  1443.            if (!EnemyCnt) { 
  1444.              Bgm(4);
  1445.              PcmFlag = -1;
  1446.            } else {
  1447.              if (!PcmFlag) {
  1448.                 Se(2);
  1449.                 PcmFlag = -1;
  1450.              }
  1451.            }
  1452.  
  1453.            Score +=(Cnt*100);
  1454.            Cnt++;
  1455.          } else {
  1456.            Enemy = Enemy->Next;
  1457.          }
  1458.        }
  1459.        if (Gate->X+15 < My->X) Gate->OpenFlag = 0;
  1460.        if (Gate->X-15 > My->X) Gate->OpenFlag = 0;
  1461.        if (Gate->Y+15 < My->Y) Gate->OpenFlag = 0;
  1462.        if (Gate->Y-15 > My->Y) Gate->OpenFlag = 0;
  1463.     }
  1464.  
  1465.     if (Gate->OpenFlag != 4) {
  1466.        Ptn = 0x0208-Gate->Status;
  1467.     } else {
  1468.        Ptn = 0x0209;
  1469.     }
  1470.  
  1471.     sp->X   = Gate->X;
  1472.     sp->Y   = Gate->Y;
  1473.     sp->Ptn = Ptn;
  1474.     sp->Pri = 3;
  1475.     sp++;
  1476.  
  1477.     Gate = Gate->Next;
  1478.   }
  1479. }
  1480.  
  1481. static char
  1482. BgmRead(void)
  1483. {
  1484.   FILE *FilePtr;
  1485.   unsigned char Str[256];
  1486.   char          *From;
  1487.   char          *To;
  1488.   unsigned char i;
  1489.   unsigned char j;
  1490.   char          *Addr;
  1491.   unsigned char BgmCnt=0;
  1492.   unsigned char BgmFile[128][32];
  1493.  
  1494.  
  1495.   FilePtr = fopen("Bgm.dat","rt");
  1496.  
  1497.   if (FilePtr != NULL) {
  1498.     i=0;
  1499.     while (!feof(FilePtr)) {
  1500.       fgets(Str,256,FilePtr);      /* 1 line read */
  1501.         From=strrchr(Str,'<');
  1502.         To  =strrchr(Str,'>');
  1503.         if (From != NULL && To != NULL) {
  1504.           j=0;
  1505.           for (Addr=From+1;Addr<=To-1;Addr++) {
  1506.             BgmFile[i][j]=*(char *)Addr;
  1507.             j++;
  1508.           }
  1509.           BgmFile[i][j] = 0;  /* end code insert */ 
  1510.           BgmFile[i][j+1] = 0;  /* end code insert */ 
  1511.           i++;
  1512.           BgmCnt++;
  1513.         }
  1514.     }
  1515.     fclose (FilePtr);
  1516.   } else {
  1517.     printf("ＢＧＭ定義（Bgm.Dat）ファイルの読み込みに失敗しました！\n");
  1518.     return 0;
  1519.   }
  1520.  
  1521.   /* FileLength check */
  1522.  
  1523.   for (i=0;i<=BgmCnt-1;i++) {
  1524.     if ((FilePtr = fopen(BgmFile[i],"rb")) != NULL) {
  1525.       BgmSize[i] = filelength(fileno(FilePtr));
  1526.       if (((unsigned char *)BgmPtr[i]=(unsigned char *)malloc(BgmSize[i])) == NULL) {
  1527.         printf("ＢＧＭファイル（%s）のメモリ確保に失敗しました！\n",BgmFile[i]);
  1528.         return 0;
  1529.       } else {
  1530.         printf("%s を %d Ｂｙｔｅ読み込んでます。\n",BgmFile[i],BgmSize[i]);
  1531.         fread(BgmPtr[i],1,BgmSize[i],FilePtr);
  1532.         fclose(FilePtr);
  1533.       }
  1534.     } else {
  1535.      printf("ＢＧＭファイル（%s）の読み込みに失敗しました。Bgm.Datを調べて下さい！\n",BgmFile[i]);
  1536.      return 0; 
  1537.     }
  1538.   }
  1539.   return -1;
  1540. }
  1541.  
  1542. static char
  1543. Bgm(unsigned char i)
  1544. {
  1545. /*  int hOpm;
  1546.  
  1547.   unsigned char *FileName = "OPM";
  1548.  
  1549.   hOpm = OPEN(FileName,0x001);
  1550.   WRITE(hOpm,BgmPtr[i],BgmSize[i]);
  1551.   CLOSE(hOpm);
  1552.  
  1553.   return -1;
  1554. */
  1555.  
  1556.   BgmStop();
  1557.  
  1558.   BgmPlay(BgmSize[i],BgmPtr[i]);
  1559.  
  1560.   return -1;
  1561.  
  1562.  
  1563. }
  1564.  
  1565. static char
  1566. SeRead(void)
  1567. {
  1568.   FILE *FilePtr;
  1569.   unsigned char Str[256];
  1570.   char          *From;
  1571.   char          *To;
  1572.   unsigned char i;
  1573.   unsigned char j;
  1574.   char          *Addr;
  1575.   unsigned char SeCnt=0;
  1576.   unsigned char SeFile[128][32];
  1577.  
  1578.  
  1579.   FilePtr = fopen("Se.dat","rt");
  1580.  
  1581.   if (FilePtr != NULL) {
  1582.     i=0;
  1583.     while (!feof(FilePtr)) {
  1584.       fgets(Str,256,FilePtr);      /* 1 line read */
  1585.         From=strrchr(Str,'<');
  1586.         To  =strrchr(Str,'>');
  1587.         if (From != NULL && To != NULL) {
  1588.           j=0;
  1589.           for (Addr=From+1;Addr<=To-1;Addr++) {
  1590.             SeFile[i][j]=*(char *)Addr;
  1591.             j++;
  1592.           }
  1593.           SeFile[i][j] = 0;  /* end code insert */ 
  1594.           SeFile[i][j+1] = 0;  /* end code insert */ 
  1595.           i++;
  1596.           SeCnt++;
  1597.         }
  1598.     }
  1599.     fclose (FilePtr);
  1600.   } else {
  1601.     printf("ＳＥ定義（Se.Dat）ファイルの読み込みに失敗しました！\n");
  1602.     return 0;
  1603.   }
  1604.  
  1605.   /* FileLength check */
  1606.  
  1607.   for (i=0;i<=SeCnt-1;i++) {
  1608.     if ((FilePtr = fopen(SeFile[i],"rb")) != NULL) {
  1609.       SeSize[i] = filelength(fileno(FilePtr));
  1610.       if (((unsigned char *)SePtr[i]=(unsigned char *)malloc(SeSize[i])) == NULL) {
  1611.         printf("ＳＥファイル（%s）のメモリ確保に失敗しました！\n",SeFile[i]);
  1612.         return 0;
  1613.       } else {
  1614.         printf("%s を %d Ｂｙｔｅ読み込んでます。\n",SeFile[i],SeSize[i]);
  1615.         fread(SePtr[i],1,SeSize[i],FilePtr);
  1616.         fclose(FilePtr);
  1617.       }
  1618.     } else {
  1619.      printf("ＳＥファイル（%s）の読み込みに失敗しました。Se.Datを調べて下さい！\n",SeFile[i]);
  1620.      return 0; 
  1621.     }
  1622.   }
  1623.   return -1;
  1624. }
  1625.  
  1626. static void
  1627. Se(unsigned char i)
  1628. {
  1629. /*
  1630.   if (ADPCMSNS()==0x02)  ADPCMMOD(00);
  1631.   ADPCMOUT(SePtr[i],0x0403,SeSize[i]);
  1632.  
  1633. */
  1634.  
  1635.   SePlay(8,(SePtr[i]+10));
  1636.  
  1637. }
  1638.  
  1639.  
  1640.  
  1641.  
  1642. /*  End Program   */
  1643. 
  1644.